home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Games / lptalk-1.3 / gag.c < prev    next >
C/C++ Source or Header  |  1995-05-03  |  7KB  |  350 lines
  1. /************************************************************************/
  2. /* LP-Talk
  3.     Version 1.0 [ 9/24/90]
  4.     Version 1.1 [ 9/27/90]
  5.     Version 1.2 [ 9/28/90]
  6. */
  7. /* TinyTalk output special processing: gags and hiliting.        */
  8. /*                                    */
  9. /*    Version 1.0 [ 2/ 2/90] : Created by ABR.            */
  10. /*        1.1 [ 2/ 5/90] : Added whisper gagging.            */
  11. /*        1.2 [ 2/ 5/90] : Minor changes to fix file problems.    */
  12. /*                                    */
  13. /************************************************************************/
  14.  
  15. #include "tl.h"
  16. #include <stdio.h>
  17.  
  18. extern char *index(), *malloc();
  19.  
  20. typedef struct gag_hilite_entry {
  21.   struct gag_hilite_entry *next, *prev;
  22.   smallstr person;
  23. } gag_hilite_entry;
  24.  
  25. gag_hilite_entry *find_person();
  26.  
  27. static int hilite_tells, hilite_whispers, hilite_other;
  28. static int gag_enabled, gag_whispers;
  29. static gag_hilite_entry *gag_list, *hilite_list;
  30.  
  31. init_hiliting()
  32. {
  33.   init_hilite_utils();
  34.   hilite_tells = FALSE;
  35.   hilite_whispers = FALSE;
  36.   hilite_other = TRUE;
  37.   hilite_list = NULL;
  38. }
  39.  
  40. init_gagging()
  41. {
  42.   gag_whispers = FALSE;
  43.   gag_enabled = TRUE;
  44.   gag_list = NULL;
  45. }
  46.  
  47. int is_gagged(what, name)
  48.   char *what, *name;
  49. {
  50.   register char *place;
  51.  
  52.   if (!gag_enabled)
  53.     return (0);
  54.  
  55.   if (find_person(gag_list, name) != NULL) { /* Are they gagged? */
  56.                     /* Don't gag kills, arrivals, or */
  57.                     /* departures. */
  58.  
  59.     place = index(what, ' ');
  60.     if (place != NULL) {
  61.       if (!strcmp(place+1, "arrives."))
  62.     return (0);
  63.       if (!strncmp(place+1, "leaves ", 7))
  64.     return (0);
  65.       if (!strncmp(place+1, "attacks ", 8))
  66.     return (0);
  67.       if (!strncmp(place+1, "killed ", 7))
  68.     return (0);
  69.     }
  70.     return (1);
  71.   }
  72.   else
  73.     return (0);
  74. }
  75.  
  76. int should_hilite(what, name)
  77.   char *what, *name;
  78. {
  79.   if (hilite_whispers && is_my_whisper(what))
  80.     return (1);
  81.  
  82.   if (!hilite_other)
  83.     return (0);
  84.  
  85.   if (find_person(hilite_list, name) != NULL) /* Are they marked for hilite? */
  86.     return (1);
  87.   else
  88.     return (0);
  89. }
  90.  
  91. int is_my_whisper(s)            /* Check if a string is a whisper. */
  92.   char *s;                /* This is a 'whisper-to-me' type. */
  93. {
  94.   register char *p;
  95.  
  96.   p = index(s, ' ');
  97.   if (p == NULL)            /* Whispers always have spaces. */
  98.     return (0);
  99.  
  100.   if (!strncmp(p+1, "whispers to you: ", 17))    /* They always have this. */
  101.     return (1);
  102.   else
  103.     return (0);
  104. }
  105.  
  106. int is_other_whisper(s)            /* Check if a string is a whisper. */
  107.   char *s;                /* This is a 'whisper-to-other'. */
  108. {
  109.   register char *p;
  110.  
  111.   if (!gag_whispers)            /* Not gagging whispers, ignore. */
  112.     return (0);
  113.  
  114.   p = index(s, ' ');
  115.   if (p == NULL)            /* Whispers always have spaces. */
  116.     return (0);
  117.  
  118.   if (!strncmp(p+1, "whispers something to ", 22))  /* They always have this. */
  119.     return (1);
  120.   else
  121.     return (0);
  122. }
  123.  
  124. int should_hilite_tells()
  125. {
  126.   return (hilite_tells);
  127. }
  128.  
  129. enable_hiliting()
  130. {
  131.   hilite_other = TRUE;
  132. }
  133.  
  134. disable_hiliting()
  135. {
  136.   hilite_other = FALSE;
  137. }
  138.  
  139. enable_tell_hiliting()
  140. {
  141.   hilite_tells = TRUE;
  142. }
  143.  
  144. disable_tell_hiliting()
  145. {
  146.   hilite_tells = FALSE;
  147. }
  148.  
  149. enable_whisper_hiliting()
  150. {
  151.   hilite_whispers = TRUE;
  152. }
  153.  
  154. disable_whisper_hiliting()
  155. {
  156.   hilite_whispers = FALSE;
  157. }
  158.  
  159. enable_gagging()
  160. {
  161.   gag_enabled = TRUE;
  162. }
  163.  
  164. disable_gagging()
  165. {
  166.   gag_enabled = FALSE;
  167. }
  168.  
  169. enable_whisper_gagging()
  170. {
  171.   gag_whispers = TRUE;
  172. }
  173.  
  174. disable_whisper_gagging()
  175. {
  176.   gag_whispers = FALSE;
  177. }
  178.  
  179. add_hilite(who)
  180.   char *who;
  181. {
  182.   add_person(&hilite_list, who);
  183. }
  184.  
  185. remove_hilite(who)
  186.   char *who;
  187. {
  188.   remove_person(&hilite_list, who);
  189. }
  190.  
  191. list_hilite()
  192. {
  193.   list_people(hilite_list);
  194.   if (hilite_other)
  195.     puts("% ** Hiliting is enabled.");
  196.   else
  197.     puts("% ** Hiliting is disabled.");
  198.   if (hilite_tells)
  199.     puts("% ** Hiliting of tells is enabled.");
  200.   else
  201.     puts("% ** Hiliting of tells is disabled.");
  202.   if (hilite_whispers)
  203.     puts("% ** Hiliting of whispers is enabled.");
  204.   else
  205.     puts("% ** Hiliting of whispers is disabled.");
  206. }
  207.  
  208. save_hilite(name)
  209.   char *name;
  210. {
  211.   save_people("/hilite ", hilite_list, name, "~/lptalk.hilite", TRUE);
  212. }
  213.  
  214. add_gag(who)
  215.   char *who;
  216. {
  217.   add_person(&gag_list, who);
  218. }
  219.  
  220. remove_gag(who)
  221.   char *who;
  222. {
  223.   remove_person(&gag_list, who);
  224. }
  225.  
  226. list_gag()
  227. {
  228.   list_people(gag_list);
  229.   if (gag_enabled)
  230.     puts("% ** Gagging is enabled.");
  231.   else
  232.     puts("% ** Gagging is disabled.");
  233. }
  234.  
  235. save_gag(name)
  236.   char *name;
  237. {
  238.   save_people("/gag ", gag_list, name, "~/lptalk.gag", FALSE);
  239. }
  240.  
  241. add_person(list, name)
  242.   gag_hilite_entry **list;
  243.   register char *name;
  244. {
  245.   register gag_hilite_entry *new;
  246.  
  247.   if (strlen(name) > SMALLSTR)        /* Silently truncate long names */
  248.     name[SMALLSTR] = '\0';
  249.  
  250.   if (find_person(*list, name) != NULL)    /* Already there, just leave 'em. */
  251.     return;
  252.  
  253.   new = (gag_hilite_entry *) malloc(sizeof(struct gag_hilite_entry));
  254.   new->prev = NULL;            /* Add at front of list */
  255.   new->next = *list;
  256.   if (new->next != NULL)        /* If not at tail of list, */
  257.     new->next->prev = new;        /* Set up backlink. */
  258.   *list = new;
  259.  
  260.   strcpy(new->person, name);
  261. }
  262.  
  263. remove_person(list, name)
  264.   gag_hilite_entry **list;
  265.   register char *name;
  266. {
  267.   register gag_hilite_entry *where;
  268.  
  269.   if (strlen(name) > SMALLSTR)        /* Silently truncate long names */
  270.     name[SMALLSTR] = '\0';
  271.  
  272.   where = find_person(*list, name);
  273.   if (where == NULL) {
  274.     fprintf(stderr, "%% Person %s was not in the list.\n", name);
  275.     return;
  276.   }
  277.  
  278.   if (where->prev == NULL)        /* Unlink from head */
  279.     *list = where->next;
  280.   else
  281.     where->prev->next = where->next;
  282.  
  283.   if (where->next != NULL)        /* If not at end, fix back link */
  284.     where->next->prev = where->prev;
  285.  
  286.   free(where);                /* Free allocated storage. */
  287. }
  288.  
  289. gag_hilite_entry *find_person(list, name)
  290.   gag_hilite_entry *list;
  291.   register char *name;
  292. {
  293.   register gag_hilite_entry *where;
  294.  
  295.   where = list;
  296.   while ((where != NULL) && (!equalstr(where->person, name)))
  297.     where = where->next;
  298.  
  299.   return (where);
  300. }
  301.  
  302. list_people(list)
  303.   gag_hilite_entry *list;
  304. {
  305.   register gag_hilite_entry *where;
  306.  
  307.   where = list;
  308.   while (where != NULL) {
  309.     printf("%% %s\n", where->person);
  310.     where = where->next;
  311.   }
  312. }
  313.  
  314. save_people(cmd, list, name, def, hilite_info)    /* Write people to a file. */
  315.   char *cmd;
  316.   gag_hilite_entry *list;
  317.   char *name, *def;
  318.   int hilite_info;
  319. {
  320.   register FILE *the_file;
  321.   register gag_hilite_entry *where;
  322.  
  323.   if (name[0] == '\0')            /* Set default name if none given. */
  324.     strcpy(name, def);
  325.  
  326.   expand_filename(name);
  327.   the_file = fopen(name, "w");        /* Open file */
  328.   if (the_file == NULL) {
  329.     fprintf(stderr,"%% Could not write to %s .\n", name);
  330.     return;
  331.   }
  332.  
  333.   if (hilite_info) {
  334.     fputs((hilite_tells ? "/hilite tells\n" : "/hilite notells\n"), the_file);
  335.     fputs((hilite_whispers ? "/hilite whispers\n" : "/hilite nowhispers\n"),
  336.       the_file);
  337.     fputc('\n', the_file);
  338.   };
  339.  
  340.   where = list;
  341.   while (where != NULL) {        /* Scan linked list, outputting */
  342.     fputs(cmd, the_file);        /* a command per person. */
  343.     fputs(where->person, the_file);
  344.     fputc('\n', the_file);
  345.     where = where->next;
  346.   }
  347.  
  348.   fclose(the_file);
  349. }
  350.